package com.quanyan.club.task;

import com.github.ltsopensource.core.commons.utils.DateUtils;
import com.github.ltsopensource.core.domain.Job;
import com.github.ltsopensource.jobclient.JobClient;
import com.github.ltsopensource.jobclient.domain.Response;
import com.quanyan.club.constants.ClubConstants;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.Map;

/**
 * @Author Hugo.Wwg
 * @Since 2016-07-04
 */
public class TimerTaskJob {

    private Logger logger = Logger.getLogger(TimerTaskJob.class);
    private final String CLUB_INTEGRAL_TASKID = "CLUB_INTEGRAL_TASKID"; //俱乐部积分统计任务ID

    @Autowired
    private JobClient jobClient;

    public void executeTask() {
        // 扫描所有没有IM groupid的俱乐部
        Job clubIMgroupidCheckJob = new Job();
        clubIMgroupidCheckJob.setTaskId(ClubConstants.CLUB_JOB_IM_GROUPIDMISSING_CHECK);
        clubIMgroupidCheckJob.setTaskTrackerNodeGroup("taskTracker_club");
        clubIMgroupidCheckJob.setNeedFeedback(true);
        clubIMgroupidCheckJob.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        clubIMgroupidCheckJob.setRepeatCount(-1);             // 无限循环
        clubIMgroupidCheckJob.setRepeatInterval(5 * 60 * 1000L);  // 5分钟 执行一次
        Response notPayActivityOrderRes = jobClient.submitJob(clubIMgroupidCheckJob);
        logger.warn("开始提交扫描所有没有IM groupid的俱乐部定时任务，返回结果: " + notPayActivityOrderRes);

        // 统计俱乐部积分的定时任务
        Job statsClubIntegral = new Job();
        statsClubIntegral.setTaskId(ClubConstants.CLUB_JOB_ID_CLUB_INTEGRAL_STATS);
        statsClubIntegral.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        statsClubIntegral.setParam("type", "statsClubIntegral");
        statsClubIntegral.setNeedFeedback(true);
        statsClubIntegral.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        statsClubIntegral.setRepeatCount(-1);  //无限循环
        statsClubIntegral.setCronExpression("0 0 2 * * ?"); //每天凌晨2点执行一次
        Response statsClubIntegralResp = jobClient.submitJob(statsClubIntegral);
        logger.warn("开始提交俱乐部积分统计定时任务，返回结果: " + statsClubIntegralResp);

        //创建周期活动
        Job weekRangeJob = new Job();
        weekRangeJob.setTaskId(ClubConstants.CLUB_JOB_ID_ACTIVITY_WEEK_RANGE_CREATE);
        weekRangeJob.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        weekRangeJob.setParam("type", "statsClubIntegral");
        weekRangeJob.setNeedFeedback(true);
        weekRangeJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        weekRangeJob.setRepeatCount(-1);  //无限循环
        weekRangeJob.setRepeatInterval(2* 60 * 60 * 1000L); //每两小时执行一次
        Response response = jobClient.submitJob(weekRangeJob);
        logger.warn("开始提交创建俱乐部周期活动定时扫描任务，返回结果: " + response);



        Job updateActivityStatusJob = new Job();
        updateActivityStatusJob.setTaskId(ClubConstants.CLUB_JOB_ID_ACTIVITY_STATUS_UPDATE);
        updateActivityStatusJob.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        updateActivityStatusJob.setParam("type", "statsClubIntegral");
        updateActivityStatusJob.setNeedFeedback(true);
        updateActivityStatusJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        updateActivityStatusJob.setRepeatCount(-1);  //无限循环
        updateActivityStatusJob.setRepeatInterval(1 * 60 * 1000L); //每一分钟执行一次
        Response statusResponse = jobClient.submitJob(updateActivityStatusJob);
        logger.warn("开始提交更新俱乐部活动状态扫描任务，返回结果: " + statusResponse);

        //俱乐部活动、赛事、提现资金统计定时任务
        Job summaryClubFinance = new Job();
        summaryClubFinance.setTaskId(ClubConstants.CLUB_JOB_SUMMARY_FINANCE);
        summaryClubFinance.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        summaryClubFinance.setNeedFeedback(true);
        summaryClubFinance.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        summaryClubFinance.setRepeatCount(-1);  //无限循环
        Calendar cal = Calendar.getInstance(Locale.CHINA);
        summaryClubFinance.setCronExpression("0 0 0 * * ?"); //每天凌晨执行一次
        //summaryClubFinance.setRepeatInterval(12 * 60 * 60 * 1000L);//12小时执行一次
        summaryClubFinance.setTriggerTime(cal.getTimeInMillis());
        Response summaryClubFinanceResp = jobClient.submitJob(summaryClubFinance);
        logger.warn("开始提交俱乐部活动、赛事、提现资金统计定时任务，返回结果: " + summaryClubFinanceResp);

        //俱乐部鸟蛋任务统计及通知
        Job clubEggTaskSummaryTask = new Job();
        clubEggTaskSummaryTask.setTaskId(ClubConstants.CLUB_JOB_TASK_NOTIFY);
        clubEggTaskSummaryTask.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        clubEggTaskSummaryTask.setNeedFeedback(true);
        clubEggTaskSummaryTask.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        clubEggTaskSummaryTask.setCronExpression("0 58 23 * * ?"); //每天23:58:00点执行一次
//        clubEggTaskSummaryTask.setRepeatInterval(5*60*1000L);
        //Response resp = jobClient.submitJob(clubEggTaskSummaryTask);
        //logger.warn("开始提交俱乐部鸟蛋任务统计定时任务，返回结果: " + resp);

        //添加俱乐部积分，12月底版本上线后执行一次，统计所有俱乐部积分，只同步一次 --create by xian-guo
//        Job clubIntegral = new Job();
//        clubIntegral.setTaskId(ClubConstants.CLUB_JOB_ID_CLUB_INTEGRAL);
//        clubIntegral.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
//        clubIntegral.setNeedFeedback(true);
//        clubIntegral.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
//        clubIntegral.setTriggerTime(DateUtils.addMinute(new Date(), 10).getTime());//10分钟后执行
//        Response respInte = jobClient.submitJob(clubIntegral);
//        logger.warn("第一次统计俱乐部积分任务提交，返回结果: " + respInte);

        //创建周期活动2
        Job weekRangeJob2 = new Job();
        weekRangeJob2.setTaskId(ClubConstants.CLUB_JOB_ID_ACTIVITY_CYCLE_RANGE_CREATE);
        weekRangeJob2.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        weekRangeJob2.setParam("type", "statsClubIntegral");
        weekRangeJob2.setNeedFeedback(true);
        weekRangeJob2.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        weekRangeJob2.setRepeatCount(-1);  //无限循环
        weekRangeJob2.setRepeatInterval(10 * 60 * 1000L); //每十分钟执行一次
        Response response2 = jobClient.submitJob(weekRangeJob2);
        logger.warn("开始提交创建俱乐部日循环活动定时扫描任务，返回结果: " + response2);

        //自动全部活动结算扫描
        Job settleRepeatJob = new Job();
        settleRepeatJob.setTaskId(ClubConstants.CLUB_JOB_ID_ACTIVITY_AUTO_SETTLE);
        settleRepeatJob.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        settleRepeatJob.setNeedFeedback(true);
        settleRepeatJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        //clubIntegral.setTriggerTime(DateUtils.addMinute(new Date(), 1).getTime());//1分钟后执行
        settleRepeatJob.setCronExpression("0 0 23 ? * SUN"); //每周日23点执行一次
        Response autoSettleResponse = jobClient.submitJob(settleRepeatJob);
        logger.warn("开始提交未定时结算活动定时扫描任务，返回结果: " + autoSettleResponse);

        //2017春节活动
        /*Job yearAvtivityJob= new Job();
        yearAvtivityJob.setTaskId(ClubConstants.CLUB_JOB_ID_YEAR_ACTIVITY_JOB);
        yearAvtivityJob.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        yearAvtivityJob.setNeedFeedback(true);
        yearAvtivityJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        yearAvtivityJob.setCronExpression("0 0 0 * * ?"); //每天凌晨0点执行一次
        Response respActivity = jobClient.submitJob(yearAvtivityJob);
        logger.warn("开始提交创建俱乐部日循环活动定时扫描任务，返回结果: " + respActivity);*/

        //自动全部活动结算扫描
        Job pullSummaryJob = new Job();
        pullSummaryJob.setTaskId(ClubConstants.CLUB_JOB_ID_PULL_SUMMARY);
        pullSummaryJob.setTaskTrackerNodeGroup("taskTracker_club"); //必须跟配置文件统一
        pullSummaryJob.setNeedFeedback(true);
        pullSummaryJob.setReplaceOnExist(true); // 当任务队列中存在这个任务的时候，是否替换更新
        //clubIntegral.setTriggerTime(DateUtils.addMinute(new Date(), 1).getTime());//1分钟后执行
        pullSummaryJob.setCronExpression("0 0 2 * * ?"); //每天凌晨2点执行一次
        Response pullSummaryResp = jobClient.submitJob(pullSummaryJob);
        logger.warn("开始提交未定时结算活动定时扫描任务，返回结果: " + pullSummaryResp);
    }

    /**
     * 提交一个定时任务，指定时间执行
     *
     * @param params      传递给业务执行类的参数
     * @param taskId      任务id
     * @param executeTime 执行时间点
     */
    public void submitTask(Map<String, String> params, String taskId,
                           long executeTime, long repeatInterval) {
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        logger.warn("executeTime=" + sf.format(new Date(executeTime)) + ", repeatInterval=" + repeatInterval);
        Job job = new Job();
        job.setTaskId(taskId);
        job.setTaskTrackerNodeGroup("taskTracker_club");
        job.setNeedFeedback(true);
        job.setReplaceOnExist(true);        // 当任务队列中存在这个任务的时候，是否替换更新
        job.setTriggerTime(executeTime);    //设置指定时间执行，在指定时间点触发
        if (params != null && params.size() > 0) {
            job.setExtParams(params);           //执行任务用到的参数
        }
        if (repeatInterval != 0) {
            job.setRepeatCount(-1); //无限循环
            job.setRepeatInterval(repeatInterval); //每间隔多久执行一次，单位秒
        }
        Response response = jobClient.submitJob(job);

        logger.warn("启动定时任务：" + taskId + ", 参数：" + params +
                ", 在" + sf.format(new Date(executeTime)) + "时执行！" + " 返回结果: " + response);
    }
}
